package com.wwu.common.utils;

import com.cronutils.model.definition.CronDefinition;
import com.cronutils.model.definition.CronDefinitionBuilder;
import com.cronutils.parser.CronParser;
import com.wwu.common.enums.WeekEnum;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerUtils;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.springframework.util.ObjectUtils;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import static com.cronutils.model.CronType.QUARTZ;

/**
 * Cron表达式工具类
 * Cron表达式格式如下：
 * *    *    *    *    *    *    *
 * -    -    -    -    -    -    -
 * |    |    |    |    |    |    |
 * |    |    |    |    |    |    + year [optional]
 * |    |    |    |    |    +----- day of week (0 - 7) (Sunday=0 or 7)
 * |    |    |    |    +---------- month (1 - 12)
 * |    |    |    +--------------- day of month (1 - 31)
 * |    |    +-------------------- hour (0 - 23)
 * |    +------------------------- minute (0 - 59)
 * +------------------------------ second (0 - 59)
 * @author 一蓑烟雨
 * @version 1.0.0
 * @date 2023-05-31 21:17
 */
public class CronUtils {
    private static final CronDefinition CRON_DEFINITION =  CronDefinitionBuilder.instanceDefinitionFor(QUARTZ);
    /** Cron表达式中文时间数组 */
    private final static String[] CRON_TIME_CN = new String[]{"秒", "分", "点", "天", "月","周", "年"};
    /** 24小时 */
    private final static Integer HOURS = 24;
    /** 60分钟 */
    private final static Integer MINUTE = 60;

    /**
     * 校验Cron表达式
     * @param expression  表达式
     * @return boolean
     * @author 一蓑烟雨
     * @date 2023/8/2 15:35
     */
    public static boolean checkValid(String expression){
        try{
            CronParser parser = new CronParser(CRON_DEFINITION);
            parser.parse(expression);
        }catch (IllegalArgumentException e){
            return false;
        }
        return true;
    }

    /**
     * 获取指定Cron表达式上次执行时间
     * @param expression  cron表达式
     * @return java.lang.String
     * @author 一蓑烟雨
     * @date 2023/8/2 15:36
     */
    public static String lastExecTime(String expression){
        try {
            if(!checkValid(expression)){
                return null;
            }

            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("Calculate Date").withSchedule(CronScheduleBuilder
                            .cronSchedule(expression))
                    .build();
            Date time0 = trigger.getStartTime();
            Date time1 = trigger.getFireTimeAfter(time0);
            Date time2 = trigger.getFireTimeAfter(time1);
            Date time3 = trigger.getFireTimeAfter(time2);

            long l = time1.getTime() -(time3.getTime() -time2.getTime());
            Date date = new Date(l);

            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            return dateFormat.format(date);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取指定Cron表达式下次执行时间
     * @param expression  cron表达式
     * @return java.lang.String
     * @author 一蓑烟雨
     * @date 2023/8/2 15:36
     */
    public static String nextExecTime(String expression){
        try {
            if(!checkValid(expression)){
                return null;
            }

            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("Calculate Date").withSchedule(CronScheduleBuilder
                            .cronSchedule(expression))
                    .build();
            Date time0 = trigger.getStartTime();
            Date time1 = trigger.getFireTimeAfter(time0);
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            return dateFormat.format(time1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取指定Cron表达式下几次次执行时间
     * @param cron  cron表达式
     * @param num  次数
     * @return java.util.List<java.lang.String>
     * @author 一蓑烟雨
     * @date 2023/8/2 15:49
     */
    public static List<String> nextExecTimes(String expression,int num){
        List<Date> dates = null;
        try {
            if(!checkValid(expression)){
                return null;
            }

            try {
                CronTriggerImpl cronTriggerImpl = new CronTriggerImpl();
                cronTriggerImpl.setCronExpression(expression);
                dates = TriggerUtils.computeFireTimes(cronTriggerImpl, null, num);
            } catch (Exception e) {
                e.printStackTrace();
            }

            if(!ObjectUtils.isEmpty(dates)){
                List<String> datesStr = new ArrayList<>();
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                for (Date date: dates) {
                    datesStr.add( dateFormat.format(date));
                }

                return datesStr;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     *  主要解析 斜杆  /：表示起始时间开始触发，然后每隔固定时间触发一次。
     *      范围值+开始值 - 间隔值 = 范围内最后执行的值；
     *      例如在Hourss域使用3/4,则意味着从第3小时到24+3-4：23小时范围内，第3小时开始触发第一次，然后每隔4小时，即7，11，15，19，23小时等分别触发一次。
     *      例如在Minutes域使用5/20,则意味着从第5分钟到60+5-20：45分范围内，第5分钟开始触发第一次，然后每隔20分钟，即25，45分钟等分别触发一次。
     *      例如在Seconds域使用8/10,则意味着从第8秒到60+8-10：58秒范围内，第8秒开始触发第一次，然后每隔10秒，即18，28，38，48，58秒等分别触发一次。
     *      *
     *   对于 *：表示匹配该域的任意值。例如在Minutes域使用*, 即表示每分钟都会触发事件。
     *   对于问号  ?：只能用在DayOfMonth和DayOfWeek两个域，其作用为不指定
     *   对于 -：表示范围。例如在Minutes域使用5-20，表示从5分到20分钟每分钟触发一次。直接进行拼接
     *   对于逗号 ,：表示列出枚举值。例如在Minutes域使用5,20 ， 则意味着在5和20分每分钟触发一次。
     *   对于L：表示最后，只能出现在DayOfMonth和DayOfMonth域。
     *      如果出现在DayOfMonth域，只能使用L，表示当月最后一天
     *      如果在DayOfMonth域
     *          使用数字（1-7）或L（和7的作用一样表示每周的最后一天周六），比如数字"5"表示每周4， "7"或"L"表示每周六
     *          使用数字（1-7）结合L，表示当月最后一周的周几，比如"5L" 表示在最后的一周的周四； "3L" 表示最后一周的周二
     *   对于#: 用于确定每个月第几个星期几，只能出现在DayOfMonth域。
     *      例如 "4#2" 表示某月的第二个星期三（4表示星期三，2表示第二周）;
     *       “6#3”表示本月第三周的星期五（6表示星期五，3表示第三周）;
     *       “2#1”表示本月第一周的星期一;
     *       “4#5”表示第五周的星期三。
     * @param expression
     * @return
     */
    public static String getCronCh(String expression) {
        StringBuffer sBuffer = new StringBuffer();
        try {
            if(expression == null || expression.length() < 1) {
                return "cron表达式为空";
            }

            String[] tmpCorns = expression.split(" ");
            if(tmpCorns.length == 6 || tmpCorns.length == 7){
                if(tmpCorns.length == 7) {
                    //解析年-Year
                    String year = tmpCorns[6];
                    if((!year.equals("*") && !year.equals("?"))) {
                        sBuffer.append(year).append(CRON_TIME_CN[6]);
                    }
                }

                //解析月-Month
                String months = tmpCorns[4];
                if(!months.equals("*") && !months.equals("?")){
                    if(months.contains("/")) {
                        sBuffer.append("从").append(months.split("/")[0]).append("日开始").append(",每").append(months.split("/")[1]).append(CRON_TIME_CN[4]);
                    }else{
                        sBuffer.append("每年").append(months).append(CRON_TIME_CN[4]);
                    }
                }

                // 解析周- DayOfMonth，主要解析 , -  1~7/L 1L~7L
                String dayOfMonth = tmpCorns[5];
                if(!dayOfMonth.equals("*") && !dayOfMonth.equals("?")){
                    // 多个数字，逗号隔开
                    if(dayOfMonth.contains(",")) {
                        sBuffer.append("每周的第").append(dayOfMonth).append(CRON_TIME_CN[3]);
                    }else if(dayOfMonth.contains("L")&& dayOfMonth.length() > 1) {
                        String weekNum = dayOfMonth.split("L")[0];
                        String weekName = judgeWeek(weekNum);
                        sBuffer.append("每月最后一周的").append(weekName);
                    }else if(dayOfMonth.contains("-")){
                        String[] splitWeek = dayOfMonth.split("-");
                        String weekOne = judgeWeek(splitWeek[0]);
                        String weekTwo = judgeWeek(splitWeek[1]);
                        sBuffer.append("每周的").append(weekOne).append("到").append(weekTwo);
                    }else if(dayOfMonth.contains("#")){
                        String[] splitWeek = dayOfMonth.split("#");
                        //前面数字表示周几
                        String weekNum = splitWeek[0];
                        //后面的数字表示第几周 范围1-4
                        String weekOfMonth = splitWeek[1];
                        String weekName = judgeWeek(weekNum);
                        sBuffer.append("每月第").append(weekOfMonth).append(CRON_TIME_CN[5]).append("的").append(weekName);
                    }else{
                        //L转换为7,便于识别
                        if("L".equals(dayOfMonth)){
                            dayOfMonth = "7";
                        }
                        int weekNums = Integer.parseInt(dayOfMonth);
                        if(weekNums < 0 || weekNums > 7){
                            return "cron表达式有误，dayOfMonth数字应为1-7";
                        }

                        sBuffer.append("每周的");
                        String weekName = judgeWeek(dayOfMonth);
                        sBuffer.append(weekName);
                    }
                }

                //解析日-days或DayOfMonth,需要解析的 / # L W
                String days = tmpCorns[3];
                if(!days.equals("?") && !days.equals("*")){
                    if(days.contains("/")){
                        sBuffer.append("每周从第").append(days.split("/")[0]).append("天开始").append(",每").append(days.split("/")[1]).append(CRON_TIME_CN[3]);
                    }else if("L".equals(days)){
                        //处理L每月的最后一天
                        sBuffer.append("每月的最后一天");
                    }else if("W".equals(days)){
                        //处理W 暂时不懂怎么处理
                        sBuffer.append(days);
                    }else if(days.contains("#")){
                        String[] splitDays = days.split("#");
                        //前面数字表示周几
                        String weekNum = splitDays[0];
                        //后面的数字表示第几周 范围1-4
                        String weekOfMonth = splitDays[1];
                        String weekName = judgeWeek(weekNum);
                        sBuffer.append("每月第").append(weekOfMonth).append(CRON_TIME_CN[5]).append("的").append(weekName);
                    } else {
                        sBuffer.append("每月第").append(days).append(CRON_TIME_CN[3]);
                    }
                }else{
                    // 前面没有内容的话，拼接下
                    if(sBuffer.toString().length() == 0 || tmpCorns.length == 7){
                        sBuffer.append("每").append(CRON_TIME_CN[3]);
                    }
                }

                //解析时 -Hours 主要解析 /
                String hours = tmpCorns[2];
                if(!hours.equals("*")){
                    if(hours.contains("/")){
                        sBuffer.append(appendGapInfo(hours, HOURS, 2));
                    }else{
                        //对于,的情况直接拼接
                        if(sBuffer.toString().length() <= 0){
                            sBuffer.append("每天").append(hours).append(CRON_TIME_CN[2]);
                        }else{
                            sBuffer.append(hours).append(CRON_TIME_CN[2]);
                        }
                    }
                }

                // 解析分- Minutes 主要解析 /
                String minutes = tmpCorns[1];
                if(!minutes.equals("*")){
                    if(minutes.contains("/")){
                        sBuffer.append(appendGapInfo(minutes, MINUTE, 1));
                    }else if(minutes.equals("0")){

                    }else if(minutes.contains("-")){
                        String[] splitMinute = minutes.split("-");
                        sBuffer.append(splitMinute[0]).append(CRON_TIME_CN[1]).append("到").append(splitMinute[1]).append(CRON_TIME_CN[1]).append("每分钟");
                    }else{
                        sBuffer.append(minutes).append(CRON_TIME_CN[1]);
                    }
                }

                //解析秒 -Seconds 主要解析 /
                String seconds = tmpCorns[0];
                if(!seconds.equals("*")){
                    if(seconds.contains("/")){
                        sBuffer.append(appendGapInfo(seconds, MINUTE, 0));
                    }else if(!seconds.equals("0")){
                        sBuffer.append(seconds).append(CRON_TIME_CN[0]);
                    }
                }

                if(sBuffer.toString().length() > 0){
                    sBuffer.append("执行一次");
                }else{
                    sBuffer.append("表达式中文转换异常");
                }
            }
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
        return sBuffer.toString();
    }


    /**
     * 根据数字转换为星期
     * @param weekNum  星期数字
     * @return java.lang.String
     * @author 一蓑烟雨
     * @date 2023/8/2 15:37
     */
    public static String judgeWeek(String weekNum){
        String weekName = WeekEnum.matchNameCn(String.valueOf(weekNum));
        int weekNums = Integer.parseInt(weekNum);
        if(weekNums < 0 || weekNums > 7 ){
            return "cron表达式有误，dayOfMonth 数字应为1-7";
        }
        return (weekName!=null && weekName!="") ? weekName : String.valueOf(weekNum);
    }

    /**
     * 进行时分秒换算
     * @param time
     * @param rangeNum
     * @param index
     * @return java.lang.String
     * @author 一蓑烟雨
     * @date 2023/8/2 15:37
     */
    private static String appendGapInfo(String time, int rangeNum, int index){
        StringBuffer sBufferTemp = new StringBuffer();
        String[] splitTime = time.split("/");
        String startNum = splitTime[0];
        String gapNum = splitTime[1];
        int endNum = rangeNum + Integer.parseInt(startNum) - Integer.parseInt(gapNum);
        String endStr = String.valueOf(endNum);
        String timeUnit = CRON_TIME_CN[index];
        sBufferTemp.append("从").append(startNum).append(timeUnit).append("开始").append("到").append(endStr).append(timeUnit).append("范围内").append(",每隔").append(gapNum).append(timeUnit);
        return sBufferTemp.toString();
    }

    public static void main(String[] args) {
        String cron = "0 0/12 * * * ?";
        System.out.println(lastExecTime(cron));
        System.out.println(nextExecTime(cron));
        List<String> strings = nextExecTimes(cron,10);
        for (String str: strings) {
            System.out.println(str);
        }
    }
}
